Graphical user interfaces by their nature are highly visual. A typical interactive session involving a user and a graphical user interface includes multiple instances of a user performing an action with regard to a displayed element (e.g., moving a pointer and selecting an icon or control) to invoke an operation and then visually observing the consequences of the operation. One way to draw a user's attention to particular elements on a graphical user interface, to indicate an active or changed status, is through animation of the graphical element. Animation, as used herein, includes changing the appearance or location of a graphical display element (e.g., an icon, a control, a window, etc.) through a sequence of incremental changes applied to the display element over a period of time. However, animation also includes time-based changes to non-visually displayed elements. Thus, animation, as referred to herein, comprises both visual (i.e., changing a visual display parameter value) and non-visual animation (i.e., changing a parameter value over time without affecting a visual display element).
Animation has the potential to enhance the usability and aesthetic appeal of computer systems and applications. User interfaces, and more particularly graphical user interfaces, occupy an important role in computer/user interactions. Animation enhances the computer/user interaction experience by providing an additional type of information or way of conveying the status of a computer program, or component thereof, to the user. For example, rather than causing a selected item to merely disappear or instantly change, animation enables a progression of changes to be displayed that, in combination with an understood context, informs a user what has occurred (e.g., a deleted file floating to a recycle bin). Furthermore, many would agree that animation makes interaction with a computer system more interesting and engages the attention of users more effectively. Furthermore, animation can also automate changes to property values. In particular a user-mode application sets up manual timers and then responding to those timers to change a value.
Animation is likely not incorporated into many user interfaces where such animation would be beneficial to a user. One reason is simply the cost of animating user interface elements. Animation is generally a time-consuming/cumbersome task. Taking a cost/benefit approach to implementing animation in graphical user interfaces, the benefit of incorporating animation should exceed its cost. Due to the current relatively high cost of animation programming, many applications that would benefit from animation are not animated because of its relatively high implementation cost.
One way to reduce the cost of animation is to reuse animation programming for multiple distinct uses. However, animation code is not generally reused. Instead, single (application) use animation code is programmed completely within the applications themselves at development time using programming tools. The animation behavior is defined explicitly within the compiled program code. During runtime, the animation is carried out by merely executing the previously programmed code segment. In addition to being a time-consuming endeavor, incorporating animation into a program potentially results in an unduly large program due to detailed data and instructions utilized to carry out the desired animation behaviors in display elements.
Efforts to enhance the programmability of animation in user interfaces have resulted in the design and provision of non-editable/monolithic animation script sequences from which executable script segments are referenced to provide a desired animation behavior. Such known animation programming methods, based for example upon the Synchronized Multimedia Integration Language (SMIL) standard, incorporate key-framing. The key-framing methods rely upon referencing particular segments of monolithic, non-editable, animation scripts.
The prior known key-framing approach exhibits a relative lack of flexibility with regard to programming new animation behaviors in a graphical user interface. The key-framing script comprises a compiled, non-editable, sequence of animation instructions that morph a display element (or composition of elements) between a designated beginning and end point. The known key-framing animation approach of selecting two points in an animation sequence and then executing the program script between those two points aids programmers seeking to implement animation behavior embodied within the previously created/compiled animation scripts. However, the key-framing approach limits the scope of supported animations to the linear progressions defined by an existing base animation script. The base animation script development is hindered by the need to identify and code all the supported animation behaviors before shipping the animation scripts to users/developers. During the lifetime of the animation script, many instances are likely to arise where a desired animation behavior is not contained in the script. However, the script is not editable by users/developers and therefore cannot be used to execute new desired animation behavior that was not previously encoded in the compiled animation script.
There is therefore a need for a more efficient, flexible, and less costly way of implementing interesting, informative, and meaningful animation behaviors into graphical user interface displays.